Qu'est-ce que l'opérateur «->» en C ++?

-> n'est pas un opérateur. Il s'agit en fait de deux opérateurs distincts, - et>.
Le code conditionnel décrémente x, tout en renvoyant la valeur d'origine (non décrémentée) de x, puis compare la valeur d'origine avec 0 à l'aide de l'opérateur>.
Pour mieux comprendre, la déclaration pourrait être rédigée comme suit:
tandis que ((x--)> 0)
|
Ou pour quelque chose de complètement différent ... x glisse à 0.
tandis que (x - \
\
\
\
> 0)
printf ("% d", x);
Pas si mathématique, mais ... chaque image peint mille mots ...
|
C'est un opérateur très compliqué, de sorte que même l'ISO / CEI JTC1 (Joint Technical Committee 1) a placé sa description dans deux parties différentes de la norme C ++.
Blague à part, ce sont deux opérateurs différents: - et> décrits respectivement aux §5.2.6 / 2 et §5.9 du Standard C ++ 03.
|
C'est équivalent à
tandis que (x -> 0)
x-- (post-décrémentation) équivaut à x = x-1 donc, le code se transforme en:
tandis que (x> 0) {
x = x-1;
// logique
}
X--; // La post-décrémentation effectuée lorsque x <= 0
|
x peut aller à zéro encore plus rapidement dans la direction opposée:
int x = 10;
tandis que (0 <---- x)
{
printf ("% d", x);
}
8 6 4 2
Vous pouvez contrôler la vitesse avec une flèche!
int x = 100;
tandis que (0 <-------------------- x)
{
printf ("% d", x);
}
90 80 70 60 50 40 30 20 10
;)
|
Ses
#include 
int main (void) {
int x = 10;
while (x--> 0) {// x va à 0
printf ("% d", x);
}
return 0;
}
Juste l'espace rend les choses amusantes, - décrémente et> compare.
|
L'utilisation de -> a une pertinence historique. La décrémentation était (et est toujours dans certains cas), plus rapide que l'incrémentation sur l'architecture x86. L'utilisation de -> suggère que x va à 0 et fait appel à ceux qui ont des antécédents mathématiques.
|
tandis que (x -> 0)
est comment cela est analysé.
|
Absolument geek, mais je vais utiliser ceci:
#define as; while
int main (int argc, char * argv [])
{
int n = atoi (argv [1]);
faire printf ("n est% d \ n", n) comme (n -> 0);
return 0;
}
|
Un livre que j'ai lu (je ne me souviens pas correctement de quel livre) disait: Les compilateurs essaient d'analyser les expressions jusqu'au plus gros jeton en utilisant la règle gauche droite.
Dans ce cas, l'expression:
x -> 0
Analyse les plus gros jetons:
jeton 1: x
jeton 2: -
jeton 3:>
jeton 4: 0
conclure: x -> 0
La même règle s'applique à cette expression:
un B
Après l'analyse:
jeton 1: a
jeton 2: -
jeton 3: -
jeton 4: -
jeton 5: b
conclure: (a -) - - b
J'espère que cela aide à comprendre l'expression compliquée ^^
|
C'est exactement la même chose que
tandis que (x--)
{
printf ("% d", x);
}
pour les nombres non négatifs
|
Quoi qu'il en soit, nous avons maintenant un opérateur "va à". "->" est facile à retenir comme une direction, et "tandis que x va à zéro" est un sens-droit.
De plus, il est un peu plus efficace que "for (x = 10; x> 0; x -)" sur certaines plateformes.
|
Ce code compare d'abord x et 0 puis décrémente x. (Aussi dit dans la première réponse: vous post-décrémentez x puis comparez x et 0 avec l'opérateur>.) Voir la sortie de ce code:
9 8 7 6 5 4 3 2 1 0
Nous comparons d'abord, puis décrémentons en voyant 0 dans la sortie.
Si nous voulons d'abord décrémenter puis comparer, utilisez ce code:
#include 
int main (void)
{
int x = 10;
while (--x> 0) // x va à 0
{
printf ("% d", x);
}
return 0;
}
Cette sortie est:
9 8 7 6 5 4 3 2 1
|
Mon compilateur imprimera 9876543210 lorsque j'exécuterai ce code.
#include 
int main()
{
int x = 10;
while (x -> 0) // x va à 0
{
std :: cout << x;
}
}
Comme prévu. Le while (x--> 0) signifie en fait while (x> 0). Le poste x - décrémente x.
tandis que (x> 0)
{
X--;
std :: cout << x;
}
est une manière différente d'écrire la même chose.
C'est bien que l'original ressemble à "tandis que x passe à 0".
|
Il manque un espace entre - et>. x est post décrémenté, c'est-à-dire décrémenté après vérification de la condition x> 0?.
|
- est l'opérateur de décrémentation et> est l'opérateur supérieur à.
Les deux opérateurs sont appliqués comme un seul comme ->.
|
C'est une combinaison de deux opérateurs. First - sert à décrémenter la valeur, et> à vérifier si la valeur est supérieure à l'opérande de droite.
#include 
int main()
{
int x = 10;
tandis que (x -> 0)
printf ("% d", x);
return 0;
}
La sortie sera:
9 8 7 6 5 4 3 2 1 0
|
En fait, x est post-décrémentation et avec cette condition est en cours de vérification. Ce n'est pas ->, c'est (x--)> 0
Remarque: la valeur de x est modifiée une fois la condition vérifiée, car elle est post-décrémentation. Certains cas similaires peuvent également se produire, par exemple:
-> x -> 0
++> x ++> 0
-> = x -> = 0
++> = x ++> = 0
|
C et C ++ obéissent à la règle "maximum munch". De la même façon a --- b est traduit en (a--) - b, dans votre cas x -> 0 se traduit par (x -)> 0.
Ce que la règle dit essentiellement, c'est qu'en allant de gauche à droite, les expressions sont formées en prenant le maximum de caractères qui formeront une expression valide.
|
Pourquoi toute cette complication?
La réponse simple à la question initiale est juste:
#include 
int main()
{
int x = 10;
tandis que (x>0)
{
printf ("% d", x);
x = x-1;
}
}
Cela fait la même chose. Je ne dis pas que vous devriez le faire comme ça, mais cela fait la même chose et aurait répondu à la question dans un seul post.
Le x-- est juste un raccourci pour ce qui précède, et> est juste un opérateur supérieur à. Pas de grand mystère!
Il y a trop de gens qui compliquent les choses simples de nos jours;)
|
De manière conventionnelle, nous définirions une condition dans la parenthèse de la boucle while () et une condition de fin entre accolades {}, mais -> définit les deux à la fois.
Par exemple:
int abc (void)
{
int a = 5
while ((a--)> 0) // Décrémente et compare les deux à la fois
{
// Code
}
}
Cela décrémente a et exécute la boucle tant que a est supérieur à 0.
Conventionnellement, ce serait comme:
int abc (void)
{
int a = 5;
tandis que (a> 0)
{
une--;
// Code
}
une--;
}
Dans les deux cas, nous faisons la même chose et atteignons les mêmes objectifs.
|
(x -> 0) signifie (x -> 0).
Vous pouvez utiliser (x ->) Sortie: 9 8 7 6 5 4 3 2 1 0
Vous pouvez utiliser (- x> 0) C'est moyen (--x> 0) Sortie: 9 8 7 6 5 4 3 2 1
Vous pouvez utiliser
(- \
\
x> 0)
Sortie: 9 8 7 6 5 4 3 2 1
Vous pouvez utiliser
(\
\
x -> 0)
Sortie: 9 8 7 6 5 4 3 2 1 0
Vous pouvez utiliser
(\
\
x -> 0
\
\
)
Sortie: 9 8 7 6 5 4 3 2 1 0
Vous pouvez également utiliser
(
X
->
)
Sortie: 9 8 7 6 5 4 3 2 1 0
De même, vous pouvez essayer de nombreuses méthodes pour exécuter cette commande avec succès.
|
Voici - est l'opérateur unaire de post-décrémentation.
while (x--> 0) // x va à 0
{
printf ("% d", x);
}
Au début, la condition sera évaluée comme
(x> 0) // 10> 0
Maintenant parce que la condition est vraie, elle ira dans la boucle avec une valeur décrémentée
x-- // x = 9
C'est pourquoi la première valeur imprimée est 9
Etc. Dans la dernière boucle x = 1, donc la condition est vraie. Selon l'opérateur unaire, la valeur est passée à x = 0 au moment de l'impression.
Maintenant, x = 0, qui évalue la condition (x> 0) comme fausse et la boucle while se termine.
|
Ce -> n'est pas du tout un opérateur. Nous avons un opérateur comme ->, mais pas comme ->. C'est juste une mauvaise interprétation de while (x--> 0) qui signifie simplement que x a l'opérateur de post-décrémentation et cette boucle fonctionnera jusqu'à ce qu'elle soit supérieure à zéro.
Une autre façon simple d'écrire ce code serait while (x--). La boucle while s'arrêtera chaque fois qu'elle obtient une condition fausse et ici il n'y a qu'un seul cas, c'est-à-dire 0. Donc, elle s'arrêtera lorsque la valeur x est décrémentée à zéro.
|
Question très active. Gagnez 10 points de réputation pour répondre à cette question. L'exigence de réputation permet de protéger cette question contre les spams et les activités sans réponse.
Ce n'est pas la réponse que vous recherchez? Parcourez les autres questions étiquetées C ++ c opérateurs de formatage de code conformité aux normes ou posez votre propre question.